#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <unordered_set>

using namespace std;

enum GAME_RESULT
{
    Alice = 1,
    Bob = -1
};

unordered_set<int> global_loser_cache;
const int CACHE_SIZE = 8;

inline bool isDecSorted(int arr[], int size)
{
    for(int i = 0; i < size - 1; i++)
    {
        if(arr[i] <= arr[i + 1]) return false;
    }
    return true;
}
inline bool isIncSorted(int arr[], int size)
{
    for(int i = 0; i < size - 1; i++)
    {
        if(arr[i] >= arr[i + 1]) return false;
    }
    return true;
}


inline int array_to_signiture(int* arr, int size)
{
    int ret = 0;
    int* pLast = arr + size;
    vector<int> v(arr, pLast);
    sort(v.begin(), v.end());
    for(int i = 0; i < size; i++)
    {
        size_t pos = lower_bound(v.begin(), v.end(), arr[i]) - v.begin() + 1;
        ret = ret * 10 + pos;
    }
    return ret;
}

int minMaxBootStrap(int input[], int size)
{
    if(size <= 2)
    {
        return Alice; 
    }
    else if(isDecSorted(input, size))
    {
        if(size % 2 == 0)
        {
            return Alice;
        }
        else
        {
            return Bob;
        }
    }
    else
    {
        for(int i = 0; i < size; i++)
        {
            int* newInput = (int*)alloca(size * sizeof(int));
            for(int x = 0; x < size; x++) newInput[x] = 0;
            int x = 0;
            for(int j = 0; j < size; j++)
            {
                if(j != i)
                {
                    newInput[x] = input[j];
                    x++;
                }
            }
            int newSize = size -1;
            if(isIncSorted(newInput, newSize))
            {
                return Alice;
            }

            if(minMaxBootStrap(newInput, newSize) == Bob)
            {
                return Alice;
            }
        }
        return Bob;
    }
}



void populate_cache(unordered_set<int>& cache)
{
    int buf[CACHE_SIZE] = {1, 2, 3, 4, 5, 6, 7, 8};
    int size = CACHE_SIZE;
    if(minMaxBootStrap(buf, size) == Bob)
    {
        cache.insert(array_to_signiture(buf, size));
    }
    while(next_permutation(buf, buf + CACHE_SIZE))
    {
        if(minMaxBootStrap(buf, size) == Bob)
        {
            cache.insert(array_to_signiture(buf, size));
        }
    }
}


inline int minMax(int input[], int size)
{
    if(CACHE_SIZE == size) 
    {
        if(global_loser_cache.find(array_to_signiture(input, size)) != global_loser_cache.end())
        {
            return Bob;
        }
        else
        {
            return Alice;
        }
    }

    if(size <= 2)
    {
        return Alice; 
    }
    else if(isDecSorted(input, size))
    {
        if(size % 2 == 0)
        {
            return Alice;
        }
        else
        {
            return Bob;
        }
    }
    else
    {
        for(int i = 0; i < size; i++)
        {
            int* newInput = (int*)alloca(size * sizeof(int));
            for(int x = 0; x < size; x++) newInput[x] = 0;
            int x = 0;
            for(int j = 0; j < size; j++)
            {
                if(j != i)
                {
                    newInput[x] = input[j];
                    x++;
                }
            }
            int newSize = size -1;
            if(isIncSorted(newInput, newSize))
            {
                return Alice;
            }

            if(minMax(newInput, newSize) == Bob)
            {
                return Alice;
            }
        }
        return Bob;
    }
}




int main() 
{
    populate_cache(global_loser_cache);

    size_t testCases = 0;
    cin >> testCases;
    for(size_t counter = 0; counter < testCases; counter++)
    {
        size_t numCount = 0;
        cin >> numCount;
        int * nums = (int*)alloca(numCount * sizeof(int));
        for(size_t i = 0; i < numCount; i++)
        {
            int num;
            cin >> num;
            nums[i] = num;
        }
        if(minMax(nums, numCount) == Alice)
        {
            cout << "Alice" << endl;
        }
        else
        {
            cout << "Bob" << endl;
        }
    }
}

